home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / fsinstall / RCS / diskFragIO.c,v < prev    next >
Text File  |  1990-01-31  |  5KB  |  171 lines
  1. head     1.1;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.1
  10. date     90.01.31.13.53.44;  author shirriff;  state Exp;
  11. branches ;
  12. next     ;
  13.  
  14.  
  15. desc
  16. @File as of 1-31-90, before replaced by symbolic link.
  17. @
  18.  
  19.  
  20.  
  21. 1.1
  22. log
  23. @Initial revision
  24. @
  25. text
  26. @/* 
  27.  * fragIO.c --
  28.  *
  29.  *    Routines to allow fragments to be read and written.
  30.  *
  31.  * Copyright (C) 1986 Regents of the University of California
  32.  * All rights reserved.
  33.  */
  34.  
  35. #ifndef lint
  36. static char rcsid[] = "$Header: /sprite/src/lib/c/disk/RCS/diskFragIO.c,v 1.4 89/10/02 23:17:55 jhh Exp $ SPRITE (Berkeley)";
  37. #endif not lint
  38.  
  39. #include "diskUtils.h"
  40. #include <stdio.h>
  41.  
  42. #define    SECTORS_PER_FRAG       (FS_FRAGMENT_SIZE / DEV_BYTES_PER_SECTOR)
  43.  
  44.  
  45. /*
  46.  *----------------------------------------------------------------------
  47.  *
  48.  * Disk_FragRead --
  49.  *    Read fragments from the disk file at a specified 1K block offset.
  50.  *    This has to use the disk geometry information to figure out
  51.  *    what disk sectors correspond to the block.
  52.  *
  53.  * Results:
  54.  *    0 if could read the disk, -1 if could not.  If couldn't read the disk
  55.  *    then the error is stored in errno.
  56.  *
  57.  * Side effects:
  58.  *    None.
  59.  *
  60.  *----------------------------------------------------------------------
  61.  */
  62. int
  63. Disk_FragRead(openFileID, headerPtr, firstFrag, numFrags, buffer)
  64.     int         openFileID; /* Handle on raw disk */
  65.     Fsdm_DomainHeader     *headerPtr; /* Domain header with geometry 
  66.                      * information. */
  67.     int         firstFrag;  /* First frag to read */
  68.     int         numFrags;   /* The number of fragments to read */
  69.     Address         buffer;        /* The buffer to read into */
  70. {
  71.     register Fsdm_Geometry    *geoPtr;
  72.     register int    cylinder;
  73.     register int    rotationalSet;
  74.     register int    blockNumber;
  75.     int            sector;
  76.  
  77.     geoPtr = &headerPtr->geometry;
  78.  
  79.     blockNumber        = firstFrag / FS_FRAGMENTS_PER_BLOCK;
  80.     cylinder        = blockNumber / geoPtr->blocksPerCylinder;
  81.     if (geoPtr->rotSetsPerCyl > 0) {
  82.     /*
  83.      * Original mapping scheme using rotational sets.
  84.      */
  85.     blockNumber        -= cylinder * geoPtr->blocksPerCylinder;
  86.     rotationalSet    = blockNumber / geoPtr->blocksPerRotSet;
  87.     blockNumber        -= rotationalSet * geoPtr->blocksPerRotSet;
  88.     
  89.     sector = geoPtr->sectorsPerTrack * geoPtr->numHeads * cylinder +
  90.          geoPtr->sectorsPerTrack * geoPtr->tracksPerRotSet *
  91.          rotationalSet + geoPtr->blockOffset[blockNumber];
  92.     sector += (firstFrag % FS_FRAGMENTS_PER_BLOCK) * SECTORS_PER_FRAG;
  93.     } else if (geoPtr->rotSetsPerCyl == FSDM_SCSI_MAPPING){
  94.     /*
  95.      * New mapping for scsi devices.
  96.      */
  97.     sector = geoPtr->sectorsPerTrack * geoPtr->numHeads * cylinder +
  98.             firstFrag * SECTORS_PER_FRAG - cylinder * 
  99.             geoPtr->blocksPerCylinder * DISK_SECTORS_PER_BLOCK;
  100.     } else {
  101.     return -1;
  102.     }
  103.     return(Disk_SectorRead(openFileID, sector, 
  104.         numFrags * SECTORS_PER_FRAG, buffer));
  105. }
  106.  
  107.  
  108. /*
  109.  *----------------------------------------------------------------------
  110.  *
  111.  * Disk_FragWrite --
  112.  *    Write fragments to the disk file at a specified 1K block offset.
  113.  *    This has to use the disk geometry information to figure out
  114.  *    what disk sectors correspond to the block.
  115.  *
  116.  * Results:
  117.  *    0 if could write the disk, -1 if could not.  If couldn't write the
  118.  *    disk then the error is stored in errno.
  119.  *
  120.  * Side effects:
  121.  *    None.
  122.  *
  123.  *----------------------------------------------------------------------
  124.  */
  125. int
  126. Disk_FragWrite(openFileID, headerPtr, firstFrag, numFrags, buffer)
  127.     int         openFileID; /* Handle on raw disk */
  128.     Fsdm_DomainHeader     *headerPtr; /* Domain header with geometry 
  129.                        information. */
  130.     int         firstFrag;  /* First frag to write */
  131.     int         numFrags;   /* The number of fragments to write */
  132.     Address         buffer;        /* The buffer to write out of. */
  133. {
  134.     register Fsdm_Geometry *geoPtr;
  135.     register int cylinder;
  136.     register int rotationalSet;
  137.     register int blockNumber;
  138.     int      sector;
  139.  
  140.     geoPtr = &headerPtr->geometry;
  141.  
  142.     blockNumber        = firstFrag / FS_FRAGMENTS_PER_BLOCK;
  143.     cylinder        = blockNumber / geoPtr->blocksPerCylinder;
  144.     if (geoPtr->rotSetsPerCyl > 0) {
  145.     /*
  146.      * Original mapping scheme using rotational sets.
  147.      */
  148.     blockNumber        -= cylinder * geoPtr->blocksPerCylinder;
  149.     rotationalSet    = blockNumber / geoPtr->blocksPerRotSet;
  150.     blockNumber        -= rotationalSet * geoPtr->blocksPerRotSet;
  151.     
  152.     sector = geoPtr->sectorsPerTrack * geoPtr->numHeads * cylinder +
  153.          geoPtr->sectorsPerTrack * geoPtr->tracksPerRotSet *
  154.          rotationalSet + geoPtr->blockOffset[blockNumber];
  155.     sector += (firstFrag % FS_FRAGMENTS_PER_BLOCK) * SECTORS_PER_FRAG;
  156.     } else if (geoPtr->rotSetsPerCyl == FSDM_SCSI_MAPPING){
  157.     /*
  158.      * New mapping for scsi devices.
  159.      */
  160.     sector = geoPtr->sectorsPerTrack * geoPtr->numHeads * cylinder +
  161.             firstFrag * SECTORS_PER_FRAG - cylinder * 
  162.             geoPtr->blocksPerCylinder * DISK_SECTORS_PER_BLOCK;
  163.     } else {
  164.     return -1;
  165.     }
  166.  
  167.      return(Disk_SectorWrite(openFileID, sector,
  168.         numFrags * SECTORS_PER_FRAG, buffer));
  169. }
  170. @
  171.